// 扩展2-1、vector使用方法
/**
 * **动态大小**的**顺序**容器
 *
 * 总结：
 * 方法
 *
 * 1.构造函数
 * std::vector<type> vec                     // 创建空的向量
 * std::vector<type> vec()                   // 创建空的向量
 * std::vector<type> vec(size_t __n)         // 创建一个元素个数为__n的向量，元素默认值是 type(), size和capacity都为__n
 * std::vector<type> vec(size_t __n,type x)         // 创建一个元素个数为__n的向量，元素默认值是 x
 * std::vector<type> vec(const vector<type>& vec2)  // 拷贝构造函数，类型必须一致
 * std::vector<type> vec(std::vector<type>::iterator n,std::vector<type>::iterator m)                     // 选择一个向量的指定区间[n,m)生成一个向量，该向量size和capacity都为m-n
 *
 * 2. 添加元素
 * void std::vector<type>::push_back(type &&__x)    // 向向量尾部插入一个元素,会改变size,可能改变capacity
 *
 * std::vector<type>::iterator std::vector<type>::insert(std::vector<type>::const_iterator __position, type &&__x) // 向向量 迭代器__position位置前面插入一个值为__x的元素
 *
 * std::vector<type>::iterator std::vector<type>::insert(std::vector<type>::const_iterator __position, std::size_t __n, const type &__x) // 向向量 迭代器__position位置前面插入_n个值为__x的元素
 *
 * std::vector<type>::iterator std::vector<type>::insert<std::vector<type>::iterator, void>(std::vector<type>::const_iterator __position, std::vector<type>::iterator __first, std::vector<type>::iterator __last) // 向向量 迭代器__position位置前面插入 另一个向量指定区间[__first,__last)内的元素
 *
 * 3.删除元素
 * std::vector<type>::iterator std::vector<type>::erase(std::vector<type>::const_iterator __position) // 删除向量中 迭代器__position位置的元素，size - 1
 *
 * std::vector<type>::iterator std::vector<type>::erase(std::vector<type>::const_iterator __first, std::vector<type>::const_iterator __last)  // 删除向量中 迭代器[__first,__last)区间内的元素， size - (__last - __first)
 *
 * void std::vector<type>::pop_back()   // 删除向量中最后一个元素，size-1
 *
 * void std::vector<type>::clear() // 删除向量中的所有元素，size = 0
 *
 * 4. 遍历元素
 * type &std::vector<type>::at(std::size_t __n) // 返回下标为__n的元素，有越界检查，返回的是引用可以作赋值语句左值
 * type &std::vector<type>::front()        // 返回向量的首元素的引用
 * type &std::vector<type>::back()         // 返回向量末尾元素的引用
 * std::vector<type>::iterator std::vector<type>::begin() // 迭代器，返回向量的头指针，指向向量的第一个元素
 * std::vector<type>::iterator std::vector<type>::end() // 迭代器，返回向量的尾指针，指向向量的最后一个元素的下一个位置, 通过*(vec.rend() - 1) 获取末尾元素值
 *
 * std::reverse_iterator<std::vector<type>::iterator> std::vector<type>::rbegin()  // 反向迭代器，指向向量最后一个元素
 *
 * std::reverse_iterator<std::vector<type>::iterator> std::vector<type>::rend()  // 反向迭代器，指向向量第一个元素的前一个位置，通过*(vec.rend()-1)获取向量的第一个元素的值
 *
 * 5. 检测函数是否为空
 * bool std::vector<type>::empty() const
 *
 * 6. 大小函数
 * std::size_t std::vector<type>::size() const  返回向量中元素的个数
 * std::size_t std::vector<type>::capacity() const 返回当前向量所能容纳的最大数量值，不够时，重新分配连续的内存空间（空间大小翻倍）
 * std::size_t std::vector<type>::max_size() const 返回最大可允许的vector元素数量值
 *
 * 7. 其他函数
 * void std::vector<int>::swap(std::vector<int> &__x)   交换两个向量内的元素，size和capacity也交换了
 *
 * void std::vector<type>::assign(std::size_t __n, const type &__val)   // 赋__n个值为__val到容器，原先容器会清空，size变为__n,capacity可能会变
 *
 * void std::vector<type>::assign<std::vector<type>::iterator, void>(std::vector<type>::iterator __first, std::vector<type>::iterator __last)    // 将迭代器区间[__first,__last)的值拷贝到该向量，size变为__last - __first
 *
 *
 */

#include <iostream>
#include <vector>
int main(void)
{
  /**
   * --构造函数--
   */
  // 空vector
  // std::vector<int> vec;
  // std::vector<int> vec();

  // std::vector<int> vec(10); // 元素个数为10
  // std::vector<int> vec(10, 1);

  // std::cout << "vec[5]:" << vec[5] << std::endl;
  // std::cout << vec.size() << "," << vec.capacity() << std::endl; // 10,10

  // 拷贝构造函数
  // std::vector<int> vec(10, 1);
  // std::vector<char> vec(10, '1');// 类型不同时会抱错

  // std::vector<int> vec1 = vec;
  // std::vector<int> vec1(vec);

  // std::vector<int> vec;
  // for (int i = 0; i < 10; i++)
  // {
  //   vec.push_back(i);// 这样会多次分配内存
  //   std::cout << vec.size() << "," << vec.capacity() << std::endl;
  // }
  /**1,1
    2,2
    3,4
    4,4
    5,8
    6,8
    7,8
    8,8
    9,16
    10,16
    */

  // 拷贝指定区间 参数是std::vector<type>::iterator
  /**
  std::vector<int> vec(10);
  for (int i = 0; i < 10; i++)
  {
    // vec.push_back(i);// 这样会多次分配内存
    vec[i] = i;
    // std::cout << vec.size() << "," << vec.capacity() << std::endl;
  }

  // std::vector<int> vec1(vec.begin() + 3, vec.end() - 2); // index [begin,end) [3,8)

  std::vector<int> vec1(20);
  vec1 = std::vector<int>(vec.begin() + 3, vec.end() - 2); // index [begin,end) [3,8)

  std::cout << "vec1[5]:" << vec1[5] << std::endl;
  // std::cout << "vec1[5]:" << vec1.at(5) << std::endl;
  std::cout << "vec1[4]:" << vec1.at(4) << std::endl;              // 7
  std::cout << vec1.size() << "," << vec1.capacity() << std::endl; // 5,5
  */

  /**
   * --添加元素--
   */

  /**
  // std::vector<int> vec;
  // vec.push_back(0);
  // std::cout << "vec[0]:" << vec[0] << std::endl;
  std::vector<int> vec(5);
  std::vector<int> vec1(5);
  for (int i = 0; i < 5; i++)
  {
    vec[i] = i;
    vec1[i] = i + 10;
  }
  // vec.insert(vec.begin() + 2, 100); // 在vec.begin+2前面插入一个元素
  // vec.insert(vec.begin() + 2, 10, 100); // 在vec.begin+2前面插入10个相同的元素
  vec.insert(vec.begin() + 2, vec1.begin() + 1, vec1.end() - 1); // 在vec.begin+2前面插入vec1 区间 [1,4)元素
  for (int i = 0; i < vec.size(); i++)
  {
    std::cout << "vec[" << i << "]: " << vec[i] << std::endl;
  }
  */

  /**
   * --删除元素--
   */
  /**
  std::vector<int> vec(10);
  for (int i = 0; i < 10; i++)
  {
    vec[i] = i;
  }
  std::cout << vec.size() << "," << vec.capacity() << std::endl; // 10,10

  // vec.erase(vec.begin() + 2);
  // vec.erase(vec.begin() + 2, vec.begin() + 5); // [2,5)
  // vec.erase(vec.begin() + 2, vec.end()); // [2,10)

  // vec.pop_back();// 删除最后一个元素 10,10
  // vec.pop_back();// 删除最后一个元素 8,10

  vec.clear(); // 清空向量中的所有元素 0,10

  std::cout << vec.size() << "," << vec.capacity() << std::endl; // 9,10
  for (int i = 0; i < (int)vec.size(); i++)
  {
    std::cout << "vec[" << i << "]:" << vec[i] << std::endl;
  }
  */

  /**
   * --4.遍历元素--
   */
  /**
  std::vector<int> vec(10);
  for (int i = 0; i < 10; i++)
  {
    vec[i] = i;
  }
  // for (int i = 0; i < 10; i++)
  // {
  //   std::cout << "vec[" << i << "]:" << vec[i] << std::endl;
  // }

  // for (int i = 0; i < (int)vec.size(); i++)
  // {
    // vec.at(i) *= 2;// 返回的是引用
  //   std::cout << "vec[" << i << "]:" << vec[i] << std::endl;
  // }
  // vec.front() += 100; // 返回向量首元素的引用
  // std::cout << "vec[0]:" << vec.at(0) << std::endl;

  // vec.back() *= 2; // 返回向量尾元素的引用
  // std::cout << "vec[last]:" << vec.at((int)vec.size() - 1) << std::endl;

  // std::vector<int>::iterator x;
  // (*vec.begin()) += 50; // 取向量的头指针，指向向量的第一个元素
  // std::cout << "vec[0]:" << *vec.begin() << std::endl;

  // *(vec.end() - 1) *= 3; // 返回向量的尾指针-1（尾指针 指向向量中的最后一个元素的下一个位置）
  // std::cout << "vec[last]:" << *(vec.end() - 1) << std::endl;

  // std::vector<int>::reverse_iterator ri = vec.rbegin(); // 反向迭代器 指向向量最后一个元素
  // std::cout << "vec[last]:" << *ri << std::endl;

  // std::vector<int>::reverse_iterator ri = vec.rend(); // 反向迭代器 指向向量第一个元素之前的那个位置

  // std::cout << "vec[0]:" << *(ri - 1) << std::endl;

  // 正向遍历元素
  // std::vector<int>::iterator vi = vec.begin();
  // int i = 0;
  // while (vi != vec.end())
  // {
  //   std::cout << "vec[" << i << "]:" << *vi << std::endl;
  //   i++;
  //   vi++;
  // }

  // 反向遍历元素
  // std::vector<int>::reverse_iterator vri = vec.rend() - 1;
  // for (int i = 0; vri != vec.rbegin() - 1; vri--, i++)
  // {
  //   std::cout << "vec[" << i << "]:" << *vri << std::endl;
  // }
  */

  /**
   * --5.判断向量是否为空--
   */

  /**
  std::vector<int> vec(10);
  for (int i = 0; i < 10; i++)
  {
    vec[i] = i;
  }
  std::cout << vec.empty() << std::endl;
  vec.clear();
  std::cout << vec.empty() << std::endl;
  */

  /**
   * --6.大小函数--
   */
  /**
  std::vector<int> vec(10);
  for (int i = 0; i < 10; i++)
  {
    vec[i] = i;
  }

  std::cout << vec.size() << "," << vec.capacity() << "," << vec.max_size() << std::endl;
  */

  /**
   * --7.其他函数--
   */
  std::vector<int> vec1(10);
  std::vector<int> vec2(10);
  for (int i = 0; i < 10; i++)
  {
    vec1[i] = i;
    vec2[i] = i * 2;
  }
  // vec2.push_back(20);

  // std::cout << vec1.size() << "," << vec1.capacity() << std::endl;
  // std::cout << vec2.size() << "," << vec2.capacity() << std::endl;

  // vec1.swap(vec2); // 交换两个向量内的值 size和capacity都变了
  // std::cout << vec1.size() << "," << vec1.capacity() << std::endl;
  // std::cout << vec2.size() << "," << vec2.capacity() << std::endl;
  // for (int i = 0; i < (int)vec1.size(); i++)
  // {
  //   std::cout << "vec1[" << i << "]:" << vec1[i] << std::endl;
  // }

  // for (int i = 0; i < (int)vec2.size(); i++)
  // {
  //   std::cout << "vec2[" << i << "]:" << vec2[i] << std::endl;
  // }
  // vec1.assign(5, 88);// 给该向量赋值5个88,会清空以前的值
  // vec1.assign(vec2.begin() + 2, vec2.end() - 2);// 将vec2区间[2,8)复制到该向量vec1
  vec1.assign(vec1.begin() + 2, vec1.end() - 2);// 将vec2区间[2,8)复制到该向量vec1
  std::cout << vec1.size() << "," << vec1.capacity() << std::endl;
  for (int i = 0; i < (int)vec1.size(); i++)
  {
    std::cout << "vec1[" << i << "]:" << vec1[i] << std::endl;
  }

  printf("---------------end------------------\n");
  return 0;
}